package o;

import com.huawei.appgallery.festivalanimation.particle.modifiers.SizeModifier;
import com.huawei.hwphy2d.physical.util.BarrierParameters;

public class fye {
    static final /* synthetic */ boolean ˏ;
    private static fzp ᐝ = new fzp();
    private final fzn ʻ = new fzn();
    private final fzp ʻॱ = new fzp();
    private final fzp ʼ = new fzp();
    private final fzp ʼॱ = new fzp();
    private final fzp ʽ = new fzp();
    private final fyn ʽॱ = new fyn();
    private final a[] ʾ = new a[2];
    private final fzp ʿ = new fzp();
    private final fzp ˈ = new fzp();
    private final fzp ˉ = new fzp();
    private final gaz ˊ;
    private final fzp ˊॱ = new fzp();
    private final fym ˋ = new fym();
    private final b ˋˊ = new b();
    private final c ˋॱ = new c();
    private final o.fyk.e ˎ = new o.fyk.e();
    private final c ˏॱ = new c();
    private final fzp ͺ = new fzp();
    private final fyj ॱ = new fyj();
    private final a[] ॱˊ = new a[2];
    private final a[] ॱˋ = new a[2];
    private final fzp ॱˎ = new fzp();
    private final fzp ॱॱ = new fzp();
    private final fzp ॱᐝ = new fzp();
    private final fzp ᐝॱ = new fzp();

    public static class a {
        public final fyn ˎ = new fyn();
        public final fzp ॱ = new fzp();

        public void ˊ(a aVar) {
            fzp o_fzp = aVar.ॱ;
            this.ॱ.ˊ = o_fzp.ˊ;
            this.ॱ.ॱ = o_fzp.ॱ;
            fyn o_fyn = aVar.ˎ;
            this.ˎ.ˋ = o_fyn.ˋ;
            this.ˎ.ˊ = o_fyn.ˊ;
            this.ˎ.ॱ = o_fyn.ॱ;
            this.ˎ.ˎ = o_fyn.ˎ;
        }
    }

    static class b {
        final fzp ʻ = new fzp();
        private final fzp ʻॱ = new fzp();
        final fzp ʼ = new fzp();
        private final a[] ʼॱ = new a[2];
        fzp ʽ = new fzp();
        private final a[] ʽॱ = new a[2];
        private final d ʾ = new d();
        private final d ʿ = new d();
        private final e ˈ = new e();
        private final fzp ˉ = new fzp();
        final fzn ˊ = new fzn();
        final fzp ˊॱ = new fzp();
        final fzp ˋ = new fzp();
        private final fzp ˋˊ = new fzp();
        boolean ˋॱ;
        final g ˎ = new g();
        fzp ˏ = new fzp();
        final fzp ˏॱ = new fzp();
        float ͺ;
        fzp ॱ = new fzp();
        final fzp ॱˊ = new fzp();
        private final fzp ॱˋ = new fzp();
        private final fzp ॱˎ = new fzp();
        final fzp ॱॱ = new fzp();
        private final a[] ॱᐝ = new a[2];
        fzp ᐝ = new fzp();
        private final fzp ᐝॱ = new fzp();

        public b() {
            for (int i = 0; i < 2; i++) {
                this.ॱᐝ[i] = new a();
                this.ʼॱ[i] = new a();
                this.ʽॱ[i] = new a();
            }
        }

        public void ˎ(fyl o_fyl, fyy o_fyy, fzn o_fzn, fzf o_fzf, fzn o_fzn2) {
            float ˎ;
            Object obj;
            float ˎ2;
            fzn.ˋ(o_fzn, o_fzn2, this.ˊ);
            fzn.ˏ(this.ˊ, o_fzf.ॱ, this.ˋ);
            this.ˏ = o_fyy.ॱ;
            this.ॱ = o_fyy.ˋ;
            this.ʽ = o_fyy.ˊ;
            this.ᐝ = o_fyy.ˏ;
            boolean z = o_fyy.ˎ;
            boolean z2 = o_fyy.ॱॱ;
            this.ॱˋ.ॱ(this.ʽ).ˎ(this.ॱ);
            this.ॱˋ.ॱ();
            this.ʻ.ˎ(this.ॱˋ.ॱ, -this.ॱˋ.ˊ);
            float ˎ3 = fzp.ˎ(this.ʻ, this.ᐝॱ.ॱ(this.ˋ).ˎ(this.ॱ));
            if (z) {
                this.ʻॱ.ॱ(this.ॱ).ˎ(this.ˏ);
                this.ʻॱ.ॱ();
                this.ॱॱ.ˎ(this.ʻॱ.ॱ, -this.ʻॱ.ˊ);
                Object obj2 = fzp.ॱ(this.ʻॱ, this.ॱˋ) >= 0.0f ? 1 : null;
                ˎ = fzp.ˎ(this.ॱॱ, this.ᐝॱ.ॱ(this.ˋ).ˎ(this.ˏ));
                obj = obj2;
            } else {
                ˎ = 0.0f;
                obj = null;
            }
            if (z2) {
                this.ॱˎ.ॱ(this.ᐝ).ˎ(this.ʽ);
                this.ॱˎ.ॱ();
                this.ʼ.ˎ(this.ॱˎ.ॱ, -this.ॱˎ.ˊ);
                obj2 = fzp.ॱ(this.ॱˋ, this.ॱˎ) > 0.0f ? 1 : null;
                ˎ2 = fzp.ˎ(this.ʼ, this.ᐝॱ.ॱ(this.ˋ).ˎ(this.ʽ));
            } else {
                obj2 = null;
                ˎ2 = 0.0f;
            }
            boolean z3;
            if (z && z2) {
                if (obj != null && obj2 != null) {
                    z3 = ˎ >= 0.0f || ˎ3 >= 0.0f || ˎ2 >= 0.0f;
                    this.ˋॱ = z3;
                    if (this.ˋॱ) {
                        this.ॱˊ.ˊ = this.ʻ.ˊ;
                        this.ॱˊ.ॱ = this.ʻ.ॱ;
                        this.ˏॱ.ˊ = this.ॱॱ.ˊ;
                        this.ˏॱ.ॱ = this.ॱॱ.ॱ;
                        this.ˊॱ.ˊ = this.ʼ.ˊ;
                        this.ˊॱ.ॱ = this.ʼ.ॱ;
                    } else {
                        this.ॱˊ.ˊ = -this.ʻ.ˊ;
                        this.ॱˊ.ॱ = -this.ʻ.ॱ;
                        this.ˏॱ.ˊ = -this.ʻ.ˊ;
                        this.ˏॱ.ॱ = -this.ʻ.ॱ;
                        this.ˊॱ.ˊ = -this.ʻ.ˊ;
                        this.ˊॱ.ॱ = -this.ʻ.ॱ;
                    }
                } else if (obj != null) {
                    z3 = ˎ >= 0.0f || (ˎ3 >= 0.0f && ˎ2 >= 0.0f);
                    this.ˋॱ = z3;
                    if (this.ˋॱ) {
                        this.ॱˊ.ˊ = this.ʻ.ˊ;
                        this.ॱˊ.ॱ = this.ʻ.ॱ;
                        this.ˏॱ.ˊ = this.ॱॱ.ˊ;
                        this.ˏॱ.ॱ = this.ॱॱ.ॱ;
                        this.ˊॱ.ˊ = this.ʻ.ˊ;
                        this.ˊॱ.ॱ = this.ʻ.ॱ;
                    } else {
                        this.ॱˊ.ˊ = -this.ʻ.ˊ;
                        this.ॱˊ.ॱ = -this.ʻ.ॱ;
                        this.ˏॱ.ˊ = -this.ʼ.ˊ;
                        this.ˏॱ.ॱ = -this.ʼ.ॱ;
                        this.ˊॱ.ˊ = -this.ʻ.ˊ;
                        this.ˊॱ.ॱ = -this.ʻ.ॱ;
                    }
                } else if (obj2 != null) {
                    z3 = ˎ2 >= 0.0f || (ˎ >= 0.0f && ˎ3 >= 0.0f);
                    this.ˋॱ = z3;
                    if (this.ˋॱ) {
                        this.ॱˊ.ˊ = this.ʻ.ˊ;
                        this.ॱˊ.ॱ = this.ʻ.ॱ;
                        this.ˏॱ.ˊ = this.ʻ.ˊ;
                        this.ˏॱ.ॱ = this.ʻ.ॱ;
                        this.ˊॱ.ˊ = this.ʼ.ˊ;
                        this.ˊॱ.ॱ = this.ʼ.ॱ;
                    } else {
                        this.ॱˊ.ˊ = -this.ʻ.ˊ;
                        this.ॱˊ.ॱ = -this.ʻ.ॱ;
                        this.ˏॱ.ˊ = -this.ʻ.ˊ;
                        this.ˏॱ.ॱ = -this.ʻ.ॱ;
                        this.ˊॱ.ˊ = -this.ॱॱ.ˊ;
                        this.ˊॱ.ॱ = -this.ॱॱ.ॱ;
                    }
                } else {
                    z3 = ˎ >= 0.0f && ˎ3 >= 0.0f && ˎ2 >= 0.0f;
                    this.ˋॱ = z3;
                    if (this.ˋॱ) {
                        this.ॱˊ.ˊ = this.ʻ.ˊ;
                        this.ॱˊ.ॱ = this.ʻ.ॱ;
                        this.ˏॱ.ˊ = this.ʻ.ˊ;
                        this.ˏॱ.ॱ = this.ʻ.ॱ;
                        this.ˊॱ.ˊ = this.ʻ.ˊ;
                        this.ˊॱ.ॱ = this.ʻ.ॱ;
                    } else {
                        this.ॱˊ.ˊ = -this.ʻ.ˊ;
                        this.ॱˊ.ॱ = -this.ʻ.ॱ;
                        this.ˏॱ.ˊ = -this.ʼ.ˊ;
                        this.ˏॱ.ॱ = -this.ʼ.ॱ;
                        this.ˊॱ.ˊ = -this.ॱॱ.ˊ;
                        this.ˊॱ.ॱ = -this.ॱॱ.ॱ;
                    }
                }
            } else if (z) {
                if (obj != null) {
                    z3 = ˎ >= 0.0f || ˎ3 >= 0.0f;
                    this.ˋॱ = z3;
                    if (this.ˋॱ) {
                        this.ॱˊ.ˊ = this.ʻ.ˊ;
                        this.ॱˊ.ॱ = this.ʻ.ॱ;
                        this.ˏॱ.ˊ = this.ॱॱ.ˊ;
                        this.ˏॱ.ॱ = this.ॱॱ.ॱ;
                        this.ˊॱ.ˊ = -this.ʻ.ˊ;
                        this.ˊॱ.ॱ = -this.ʻ.ॱ;
                    } else {
                        this.ॱˊ.ˊ = -this.ʻ.ˊ;
                        this.ॱˊ.ॱ = -this.ʻ.ॱ;
                        this.ˏॱ.ˊ = this.ʻ.ˊ;
                        this.ˏॱ.ॱ = this.ʻ.ॱ;
                        this.ˊॱ.ˊ = -this.ʻ.ˊ;
                        this.ˊॱ.ॱ = -this.ʻ.ॱ;
                    }
                } else {
                    z3 = ˎ >= 0.0f && ˎ3 >= 0.0f;
                    this.ˋॱ = z3;
                    if (this.ˋॱ) {
                        this.ॱˊ.ˊ = this.ʻ.ˊ;
                        this.ॱˊ.ॱ = this.ʻ.ॱ;
                        this.ˏॱ.ˊ = this.ʻ.ˊ;
                        this.ˏॱ.ॱ = this.ʻ.ॱ;
                        this.ˊॱ.ˊ = -this.ʻ.ˊ;
                        this.ˊॱ.ॱ = -this.ʻ.ॱ;
                    } else {
                        this.ॱˊ.ˊ = -this.ʻ.ˊ;
                        this.ॱˊ.ॱ = -this.ʻ.ॱ;
                        this.ˏॱ.ˊ = this.ʻ.ˊ;
                        this.ˏॱ.ॱ = this.ʻ.ॱ;
                        this.ˊॱ.ˊ = -this.ॱॱ.ˊ;
                        this.ˊॱ.ॱ = -this.ॱॱ.ॱ;
                    }
                }
            } else if (!z2) {
                this.ˋॱ = ˎ3 >= 0.0f;
                if (this.ˋॱ) {
                    this.ॱˊ.ˊ = this.ʻ.ˊ;
                    this.ॱˊ.ॱ = this.ʻ.ॱ;
                    this.ˏॱ.ˊ = -this.ʻ.ˊ;
                    this.ˏॱ.ॱ = -this.ʻ.ॱ;
                    this.ˊॱ.ˊ = -this.ʻ.ˊ;
                    this.ˊॱ.ॱ = -this.ʻ.ॱ;
                } else {
                    this.ॱˊ.ˊ = -this.ʻ.ˊ;
                    this.ॱˊ.ॱ = -this.ʻ.ॱ;
                    this.ˏॱ.ˊ = this.ʻ.ˊ;
                    this.ˏॱ.ॱ = this.ʻ.ॱ;
                    this.ˊॱ.ˊ = this.ʻ.ˊ;
                    this.ˊॱ.ॱ = this.ʻ.ॱ;
                }
            } else if (obj2 != null) {
                z3 = ˎ3 >= 0.0f || ˎ2 >= 0.0f;
                this.ˋॱ = z3;
                if (this.ˋॱ) {
                    this.ॱˊ.ˊ = this.ʻ.ˊ;
                    this.ॱˊ.ॱ = this.ʻ.ॱ;
                    this.ˏॱ.ˊ = -this.ʻ.ˊ;
                    this.ˏॱ.ॱ = -this.ʻ.ॱ;
                    this.ˊॱ.ˊ = this.ʼ.ˊ;
                    this.ˊॱ.ॱ = this.ʼ.ॱ;
                } else {
                    this.ॱˊ.ˊ = -this.ʻ.ˊ;
                    this.ॱˊ.ॱ = -this.ʻ.ॱ;
                    this.ˏॱ.ˊ = -this.ʻ.ˊ;
                    this.ˏॱ.ॱ = -this.ʻ.ॱ;
                    this.ˊॱ.ˊ = this.ʻ.ˊ;
                    this.ˊॱ.ॱ = this.ʻ.ॱ;
                }
            } else {
                z3 = ˎ3 >= 0.0f && ˎ2 >= 0.0f;
                this.ˋॱ = z3;
                if (this.ˋॱ) {
                    this.ॱˊ.ˊ = this.ʻ.ˊ;
                    this.ॱˊ.ॱ = this.ʻ.ॱ;
                    this.ˏॱ.ˊ = -this.ʻ.ˊ;
                    this.ˏॱ.ॱ = -this.ʻ.ॱ;
                    this.ˊॱ.ˊ = this.ʻ.ˊ;
                    this.ˊॱ.ॱ = this.ʻ.ॱ;
                } else {
                    this.ॱˊ.ˊ = -this.ʻ.ˊ;
                    this.ॱˊ.ॱ = -this.ʻ.ॱ;
                    this.ˏॱ.ˊ = -this.ʼ.ˊ;
                    this.ˏॱ.ॱ = -this.ʼ.ॱ;
                    this.ˊॱ.ˊ = this.ʻ.ˊ;
                    this.ˊॱ.ॱ = this.ʻ.ॱ;
                }
            }
            this.ˎ.ˏ = o_fzf.ˎ;
            for (int i = 0; i < o_fzf.ˎ; i++) {
                fzn.ˏ(this.ˊ, o_fzf.ˏ[i], this.ˎ.ॱ[i]);
                fzi.ॱ(this.ˊ.ˏ, o_fzf.ˋ[i], this.ˎ.ˋ[i]);
            }
            this.ͺ = 2.0f * fzo.ᐝॱ;
            o_fyl.ˏ = 0;
            ˏ(this.ʿ);
            if (this.ʿ.ॱ != b.UNKNOWN && this.ʿ.ˊ <= this.ͺ) {
                ˎ(this.ʾ);
                if (this.ʾ.ॱ == b.UNKNOWN || this.ʾ.ˊ <= this.ͺ) {
                    d dVar;
                    int i2;
                    if (this.ʾ.ॱ == b.UNKNOWN) {
                        dVar = this.ʿ;
                    } else if (this.ʾ.ˊ > (0.98f * this.ʿ.ˊ) + 0.001f) {
                        dVar = this.ʾ;
                    } else {
                        dVar = this.ʿ;
                    }
                    a aVar = this.ॱᐝ[0];
                    a aVar2 = this.ॱᐝ[1];
                    if (dVar.ॱ == b.EDGE_A) {
                        o_fyl.ॱ = o.fyl.d.FACE_A;
                        int i3 = 0;
                        float ˎ4 = fzp.ˎ(this.ॱˊ, this.ˎ.ˋ[0]);
                        for (i2 = 1; i2 < this.ˎ.ˏ; i2++) {
                            ˎ = fzp.ˎ(this.ॱˊ, this.ˎ.ˋ[i2]);
                            if (ˎ < ˎ4) {
                                ˎ4 = ˎ;
                                i3 = i2;
                            }
                        }
                        i2 = i3 + 1 < this.ˎ.ˏ ? i3 + 1 : 0;
                        aVar.ॱ.ॱ(this.ˎ.ॱ[i3]);
                        aVar.ˎ.ˋ = (byte) 0;
                        aVar.ˎ.ˊ = (byte) i3;
                        aVar.ˎ.ॱ = (byte) o.fyn.b.FACE.ordinal();
                        aVar.ˎ.ˎ = (byte) o.fyn.b.VERTEX.ordinal();
                        aVar2.ॱ.ॱ(this.ˎ.ॱ[i2]);
                        aVar2.ˎ.ˋ = (byte) 0;
                        aVar2.ˎ.ˊ = (byte) i2;
                        aVar2.ˎ.ॱ = (byte) o.fyn.b.FACE.ordinal();
                        aVar2.ˎ.ˎ = (byte) o.fyn.b.VERTEX.ordinal();
                        if (this.ˋॱ) {
                            this.ˈ.ˋ = 0;
                            this.ˈ.ˎ = 1;
                            this.ˈ.ˊ.ॱ(this.ॱ);
                            this.ˈ.ˏ.ॱ(this.ʽ);
                            this.ˈ.ॱ.ॱ(this.ʻ);
                        } else {
                            this.ˈ.ˋ = 1;
                            this.ˈ.ˎ = 0;
                            this.ˈ.ˊ.ॱ(this.ʽ);
                            this.ˈ.ˏ.ॱ(this.ॱ);
                            this.ˈ.ॱ.ॱ(this.ʻ).ˎ();
                        }
                    } else {
                        o_fyl.ॱ = o.fyl.d.FACE_B;
                        aVar.ॱ.ॱ(this.ॱ);
                        aVar.ˎ.ˋ = (byte) 0;
                        aVar.ˎ.ˊ = (byte) dVar.ˋ;
                        aVar.ˎ.ॱ = (byte) o.fyn.b.VERTEX.ordinal();
                        aVar.ˎ.ˎ = (byte) o.fyn.b.FACE.ordinal();
                        aVar2.ॱ.ॱ(this.ʽ);
                        aVar2.ˎ.ˋ = (byte) 0;
                        aVar2.ˎ.ˊ = (byte) dVar.ˋ;
                        aVar2.ˎ.ॱ = (byte) o.fyn.b.VERTEX.ordinal();
                        aVar2.ˎ.ˎ = (byte) o.fyn.b.FACE.ordinal();
                        this.ˈ.ˋ = dVar.ˋ;
                        this.ˈ.ˎ = this.ˈ.ˋ + 1 < this.ˎ.ˏ ? this.ˈ.ˋ + 1 : 0;
                        this.ˈ.ˊ.ॱ(this.ˎ.ॱ[this.ˈ.ˋ]);
                        this.ˈ.ˏ.ॱ(this.ˎ.ॱ[this.ˈ.ˎ]);
                        this.ˈ.ॱ.ॱ(this.ˎ.ˋ[this.ˈ.ˋ]);
                    }
                    this.ˈ.ʻ.ˎ(this.ˈ.ॱ.ॱ, -this.ˈ.ॱ.ˊ);
                    this.ˈ.ॱॱ.ॱ(this.ˈ.ʻ).ˎ();
                    this.ˈ.ᐝ = fzp.ˎ(this.ˈ.ʻ, this.ˈ.ˊ);
                    this.ˈ.ʼ = fzp.ˎ(this.ˈ.ॱॱ, this.ˈ.ˏ);
                    if (fye.ˎ(this.ʼॱ, this.ॱᐝ, this.ˈ.ʻ, this.ˈ.ᐝ, this.ˈ.ˋ) >= fzo.ʼ && fye.ˎ(this.ʽॱ, this.ʼॱ, this.ˈ.ॱॱ, this.ˈ.ʼ, this.ˈ.ˎ) >= fzo.ʼ) {
                        if (dVar.ॱ == b.EDGE_A) {
                            o_fyl.ˋ.ॱ(this.ˈ.ॱ);
                            o_fyl.ˎ.ॱ(this.ˈ.ˊ);
                        } else {
                            o_fyl.ˋ.ॱ(o_fzf.ˋ[this.ˈ.ˋ]);
                            o_fyl.ˎ.ॱ(o_fzf.ˏ[this.ˈ.ˋ]);
                        }
                        int i4 = 0;
                        for (i2 = 0; i2 < fzo.ʼ; i2++) {
                            if (fzp.ˎ(this.ˈ.ॱ, this.ᐝॱ.ॱ(this.ʽॱ[i2].ॱ).ˎ(this.ˈ.ˊ)) <= this.ͺ) {
                                fyo o_fyo = o_fyl.ˊ[i4];
                                if (dVar.ॱ == b.EDGE_A) {
                                    fzn.ˎ(this.ˊ, this.ʽॱ[i2].ॱ, o_fyo.ˊ);
                                    o_fyo.ˋ.ॱ(this.ʽॱ[i2].ˎ);
                                } else {
                                    o_fyo.ˊ.ॱ(this.ʽॱ[i2].ॱ);
                                    o_fyo.ˋ.ॱ = this.ʽॱ[i2].ˎ.ˎ;
                                    o_fyo.ˋ.ˎ = this.ʽॱ[i2].ˎ.ॱ;
                                    o_fyo.ˋ.ˋ = this.ʽॱ[i2].ˎ.ˊ;
                                    o_fyo.ˋ.ˊ = this.ʽॱ[i2].ˎ.ˋ;
                                }
                                i4++;
                            }
                        }
                        o_fyl.ˏ = i4;
                    }
                }
            }
        }

        public void ˏ(d dVar) {
            int i = 0;
            dVar.ॱ = b.EDGE_A;
            dVar.ˋ = this.ˋॱ ? 0 : 1;
            dVar.ˊ = Float.MAX_VALUE;
            float f = this.ॱˊ.ˊ;
            float f2 = this.ॱˊ.ॱ;
            while (i < this.ˎ.ˏ) {
                fzp o_fzp = this.ˎ.ॱ[i];
                float f3 = ((o_fzp.ॱ - this.ॱ.ॱ) * f2) + ((o_fzp.ˊ - this.ॱ.ˊ) * f);
                if (f3 < dVar.ˊ) {
                    dVar.ˊ = f3;
                }
                i++;
            }
        }

        public void ˎ(d dVar) {
            dVar.ॱ = b.UNKNOWN;
            dVar.ˋ = -1;
            dVar.ˊ = -3.4028235E38f;
            this.ˉ.ˊ = -this.ॱˊ.ॱ;
            this.ˉ.ॱ = this.ॱˊ.ˊ;
            for (int i = 0; i < this.ˎ.ˏ; i++) {
                fzp o_fzp = this.ˎ.ˋ[i];
                fzp o_fzp2 = this.ˎ.ॱ[i];
                this.ˋˊ.ˊ = -o_fzp.ˊ;
                this.ˋˊ.ॱ = -o_fzp.ॱ;
                float f = ((o_fzp2.ˊ - this.ॱ.ˊ) * this.ˋˊ.ˊ) + ((o_fzp2.ॱ - this.ॱ.ॱ) * this.ˋˊ.ॱ);
                float f2 = o_fzp2.ˊ - this.ʽ.ˊ;
                f2 *= this.ˋˊ.ˊ;
                f = fzm.ॱ(f, ((o_fzp2.ॱ - this.ʽ.ॱ) * this.ˋˊ.ॱ) + f2);
                if (f > this.ͺ) {
                    dVar.ॱ = b.EDGE_B;
                    dVar.ˋ = i;
                    dVar.ˊ = f;
                    return;
                }
                if ((this.ˋˊ.ˊ * this.ˉ.ˊ) + (this.ˋˊ.ॱ * this.ˉ.ॱ) >= 0.0f) {
                    if (fzp.ˎ(this.ᐝॱ.ॱ(this.ˋˊ).ˎ(this.ˊॱ), this.ॱˊ) < (-fzo.ˋॱ)) {
                    }
                    if (f > dVar.ˊ) {
                        dVar.ॱ = b.EDGE_B;
                        dVar.ˋ = i;
                        dVar.ˊ = f;
                    }
                } else {
                    if (fzp.ˎ(this.ᐝॱ.ॱ(this.ˋˊ).ˎ(this.ˏॱ), this.ॱˊ) < (-fzo.ˋॱ)) {
                    }
                    if (f > dVar.ˊ) {
                        dVar.ॱ = b.EDGE_B;
                        dVar.ˋ = i;
                        dVar.ˊ = f;
                    }
                }
            }
        }
    }

    static class c {
        public int ˊ;
        public float ˏ;

        private c() {
        }
    }

    static class d {
        float ˊ;
        int ˋ;
        b ॱ;

        enum b {
            UNKNOWN,
            EDGE_A,
            EDGE_B
        }

        d() {
        }
    }

    static class e {
        final fzp ʻ = new fzp();
        float ʼ;
        final fzp ˊ = new fzp();
        int ˋ;
        int ˎ;
        final fzp ˏ = new fzp();
        final fzp ॱ = new fzp();
        final fzp ॱॱ = new fzp();
        float ᐝ;

        e() {
        }
    }

    static class g {
        final fzp[] ˋ = new fzp[fzo.ˊॱ];
        int ˏ;
        final fzp[] ॱ = new fzp[fzo.ˊॱ];

        public g() {
            for (int i = 0; i < this.ॱ.length; i++) {
                this.ॱ[i] = new fzp();
                this.ˋ[i] = new fzp();
            }
        }
    }

    static {
        boolean z;
        if (fye.class.desiredAssertionStatus()) {
            z = false;
        } else {
            z = true;
        }
        ˏ = z;
    }

    public fye(gaz o_gaz) {
        this.ॱˊ[0] = new a();
        this.ॱˊ[1] = new a();
        this.ॱˋ[0] = new a();
        this.ॱˋ[1] = new a();
        this.ʾ[0] = new a();
        this.ʾ[1] = new a();
        this.ˊ = o_gaz;
    }

    public final boolean ˊ(fzg o_fzg, int i, fzg o_fzg2, int i2, fzn o_fzn, fzn o_fzn2) {
        this.ॱ.ˏ.ˊ(o_fzg, i);
        this.ॱ.ॱ.ˊ(o_fzg2, i2);
        this.ॱ.ˎ.ˊ(o_fzn);
        this.ॱ.ˋ.ˊ(o_fzn2);
        this.ॱ.ˊ = true;
        this.ˎ.ˋ = 0;
        this.ˊ.ॱˊ().ˏ(this.ˋ, this.ˎ, this.ॱ);
        if (this.ˋ.ˏ < 1.1920929E-6f) {
            return true;
        }
        return false;
    }

    public static final int ˎ(a[] aVarArr, a[] aVarArr2, fzp o_fzp, float f, int i) {
        int i2;
        int i3 = 1;
        a aVar = aVarArr2[0];
        a aVar2 = aVarArr2[1];
        fzp o_fzp2 = aVar.ॱ;
        fzp o_fzp3 = aVar2.ॱ;
        float ˎ = fzp.ˎ(o_fzp, o_fzp2) - f;
        float ˎ2 = fzp.ˎ(o_fzp, o_fzp3) - f;
        if (ˎ <= 0.0f) {
            aVarArr[0].ˊ(aVar);
        } else {
            i3 = 0;
        }
        if (ˎ2 <= 0.0f) {
            i2 = i3 + 1;
            aVarArr[i3].ˊ(aVar2);
        } else {
            i2 = i3;
        }
        if (ˎ * ˎ2 >= 0.0f) {
            return i2;
        }
        float f2 = ˎ / (ˎ - ˎ2);
        aVar2 = aVarArr[i2];
        aVar2.ॱ.ˊ = o_fzp2.ˊ + ((o_fzp3.ˊ - o_fzp2.ˊ) * f2);
        aVar2.ॱ.ॱ = (f2 * (o_fzp3.ॱ - o_fzp2.ॱ)) + o_fzp2.ॱ;
        aVar2.ˎ.ˋ = (byte) i;
        aVar2.ˎ.ˊ = aVar.ˎ.ˊ;
        aVar2.ˎ.ॱ = (byte) o.fyn.b.VERTEX.ordinal();
        aVar2.ˎ.ˎ = (byte) o.fyn.b.FACE.ordinal();
        return i2 + 1;
    }

    public final void ॱ(fyl o_fyl, fyz o_fyz, fzn o_fzn, fyz o_fyz2, fzn o_fzn2) {
        o_fyl.ˏ = 0;
        fzp o_fzp = o_fyz.ˏ;
        fzp o_fzp2 = o_fyz2.ˏ;
        float f = ((o_fzn2.ˏ.ˊ * o_fzp2.ˊ) - (o_fzn2.ˏ.ˏ * o_fzp2.ॱ)) + o_fzn2.ˊ.ˊ;
        float f2 = f - (((o_fzn.ˏ.ˊ * o_fzp.ˊ) - (o_fzn.ˏ.ˏ * o_fzp.ॱ)) + o_fzn.ˊ.ˊ);
        float f3 = (((o_fzn2.ˏ.ˏ * o_fzp2.ˊ) + (o_fzn2.ˏ.ˊ * o_fzp2.ॱ)) + o_fzn2.ˊ.ॱ) - (((o_fzn.ˏ.ˏ * o_fzp.ˊ) + (o_fzn.ˏ.ˊ * o_fzp.ॱ)) + o_fzn.ˊ.ॱ);
        f2 = (f2 * f2) + (f3 * f3);
        f3 = o_fyz.ʼ + o_fyz2.ʼ;
        if (f2 <= f3 * f3) {
            o_fyl.ॱ = o.fyl.d.CIRCLES;
            o_fyl.ˎ.ॱ(o_fzp);
            o_fyl.ˋ.ˊ();
            o_fyl.ˏ = 1;
            o_fyl.ˊ[0].ˊ.ॱ(o_fzp2);
            o_fyl.ˊ[0].ˋ.ॱ();
        }
    }

    public final void ॱ(fyl o_fyl, fzf o_fzf, fzn o_fzn, fyz o_fyz, fzn o_fzn2) {
        fzp o_fzp;
        o_fyl.ˏ = 0;
        fzp o_fzp2 = o_fyz.ˏ;
        fzi o_fzi = o_fzn2.ˏ;
        fzi o_fzi2 = o_fzn.ˏ;
        float f = (((o_fzi.ˊ * o_fzp2.ˊ) - (o_fzi.ˏ * o_fzp2.ॱ)) + o_fzn2.ˊ.ˊ) - o_fzn.ˊ.ˊ;
        float f2 = (((o_fzi.ˊ * o_fzp2.ॱ) + (o_fzi.ˏ * o_fzp2.ˊ)) + o_fzn2.ˊ.ॱ) - o_fzn.ˊ.ॱ;
        float f3 = (o_fzi2.ˏ * f2) + (o_fzi2.ˊ * f);
        float f4 = (f * (-o_fzi2.ˏ)) + (f2 * o_fzi2.ˊ);
        int i = 0;
        float f5 = -3.4028235E38f;
        float f6 = o_fzf.ʼ + o_fyz.ʼ;
        int i2 = o_fzf.ˎ;
        fzp[] o_fzpArr = o_fzf.ˏ;
        fzp[] o_fzpArr2 = o_fzf.ˋ;
        int i3 = 0;
        while (i3 < i2) {
            o_fzp = o_fzpArr[i3];
            f2 = ((f4 - o_fzp.ॱ) * o_fzpArr2[i3].ॱ) + ((f3 - o_fzp.ˊ) * o_fzpArr2[i3].ˊ);
            if (f2 <= f6) {
                int i4;
                if (f2 > f5) {
                    i4 = i3;
                } else {
                    f2 = f5;
                    i4 = i;
                }
                i3++;
                i = i4;
                f5 = f2;
            } else {
                return;
            }
        }
        int i5 = i + 1 < i2 ? i + 1 : 0;
        fzp o_fzp3 = o_fzpArr[i];
        o_fzp = o_fzpArr[i5];
        if (f5 < 1.1920929E-7f) {
            o_fyl.ˏ = 1;
            o_fyl.ॱ = o.fyl.d.FACE_A;
            fzp o_fzp4 = o_fzpArr2[i];
            o_fyl.ˋ.ˊ = o_fzp4.ˊ;
            o_fyl.ˋ.ॱ = o_fzp4.ॱ;
            o_fyl.ˎ.ˊ = (o_fzp3.ˊ + o_fzp.ˊ) * 0.5f;
            o_fyl.ˎ.ॱ = (o_fzp.ॱ + o_fzp3.ॱ) * 0.5f;
            fyo o_fyo = o_fyl.ˊ[0];
            o_fyo.ˊ.ˊ = o_fzp2.ˊ;
            o_fyo.ˊ.ॱ = o_fzp2.ॱ;
            o_fyo.ˋ.ॱ();
            return;
        }
        float f7 = ((f3 - o_fzp.ˊ) * (o_fzp3.ˊ - o_fzp.ˊ)) + ((f4 - o_fzp.ॱ) * (o_fzp3.ॱ - o_fzp.ॱ));
        if (((f3 - o_fzp3.ˊ) * (o_fzp.ˊ - o_fzp3.ˊ)) + ((f4 - o_fzp3.ॱ) * (o_fzp.ॱ - o_fzp3.ॱ)) <= 0.0f) {
            f2 = f3 - o_fzp3.ˊ;
            f5 = f4 - o_fzp3.ॱ;
            if ((f2 * f2) + (f5 * f5) <= f6 * f6) {
                o_fyl.ˏ = 1;
                o_fyl.ॱ = o.fyl.d.FACE_A;
                o_fyl.ˋ.ˊ = f3 - o_fzp3.ˊ;
                o_fyl.ˋ.ॱ = f4 - o_fzp3.ॱ;
                o_fyl.ˋ.ॱ();
                o_fyl.ˎ.ॱ(o_fzp3);
                o_fyl.ˊ[0].ˊ.ॱ(o_fzp2);
                o_fyl.ˊ[0].ˋ.ॱ();
            }
        } else if (f7 <= 0.0f) {
            f5 = f3 - o_fzp.ˊ;
            f = f4 - o_fzp.ॱ;
            if ((f5 * f5) + (f * f) <= f6 * f6) {
                o_fyl.ˏ = 1;
                o_fyl.ॱ = o.fyl.d.FACE_A;
                o_fyl.ˋ.ˊ = f3 - o_fzp.ˊ;
                o_fyl.ˋ.ॱ = f4 - o_fzp.ॱ;
                o_fyl.ˋ.ॱ();
                o_fyl.ˎ.ॱ(o_fzp);
                o_fyl.ˊ[0].ˊ.ॱ(o_fzp2);
                o_fyl.ˊ[0].ˋ.ॱ();
            }
        } else {
            f5 = (o_fzp3.ˊ + o_fzp.ˊ) * 0.5f;
            f2 = (o_fzp.ॱ + o_fzp3.ॱ) * 0.5f;
            f = f3 - f5;
            f3 = f4 - f2;
            fzp o_fzp5 = o_fzpArr2[i];
            if ((f * o_fzp5.ˊ) + (f3 * o_fzp5.ॱ) <= f6) {
                o_fyl.ˏ = 1;
                o_fyl.ॱ = o.fyl.d.FACE_A;
                o_fyl.ˋ.ॱ(o_fzpArr2[i]);
                o_fyl.ˎ.ˊ = f5;
                o_fyl.ˎ.ॱ = f2;
                o_fyl.ˊ[0].ˊ.ॱ(o_fzp2);
                o_fyl.ˊ[0].ˋ.ॱ();
            }
        }
    }

    public final void ˋ(c cVar, fzf o_fzf, fzn o_fzn, fzf o_fzf2, fzn o_fzn2) {
        int i = o_fzf.ˎ;
        int i2 = o_fzf2.ˎ;
        fzp[] o_fzpArr = o_fzf.ˋ;
        fzp[] o_fzpArr2 = o_fzf.ˏ;
        fzp[] o_fzpArr3 = o_fzf2.ˏ;
        fzn.ˋ(o_fzn2, o_fzn, this.ʻ);
        fzi o_fzi = this.ʻ.ˏ;
        int i3 = 0;
        float f = -3.4028235E38f;
        int i4 = 0;
        while (i4 < i) {
            int i5;
            fzi.ॱ(o_fzi, o_fzpArr[i4], this.ʽ);
            fzn.ˏ(this.ʻ, o_fzpArr2[i4], this.ॱॱ);
            float f2 = Float.MAX_VALUE;
            int i6 = 0;
            while (i6 < i2) {
                fzp o_fzp = o_fzpArr3[i6];
                float f3 = ((o_fzp.ॱ - this.ॱॱ.ॱ) * this.ʽ.ॱ) + (this.ʽ.ˊ * (o_fzp.ˊ - this.ॱॱ.ˊ));
                if (f3 >= f2) {
                    f3 = f2;
                }
                i6++;
                f2 = f3;
            }
            if (f2 > f) {
                i5 = i4;
            } else {
                f2 = f;
                i5 = i3;
            }
            i4++;
            f = f2;
            i3 = i5;
        }
        cVar.ˊ = i3;
        cVar.ˏ = f;
    }

    public final void ˎ(a[] aVarArr, fzf o_fzf, fzn o_fzn, int i, fzf o_fzf2, fzn o_fzn2) {
        int i2 = o_fzf.ˎ;
        fzp[] o_fzpArr = o_fzf.ˋ;
        int i3 = o_fzf2.ˎ;
        fzp[] o_fzpArr2 = o_fzf2.ˏ;
        fzp[] o_fzpArr3 = o_fzf2.ˋ;
        if (ˏ || (i >= 0 && i < i2)) {
            a aVar = aVarArr[0];
            a aVar2 = aVarArr[1];
            fzi o_fzi = o_fzn.ˏ;
            fzi o_fzi2 = o_fzn2.ˏ;
            fzp o_fzp = o_fzpArr[i];
            float f = (o_fzi.ˊ * o_fzp.ˊ) - (o_fzi.ˏ * o_fzp.ॱ);
            float f2 = (o_fzi.ˊ * o_fzp.ॱ) + (o_fzi.ˏ * o_fzp.ˊ);
            float f3 = (o_fzi2.ˊ * f) + (o_fzi2.ˏ * f2);
            float f4 = ((-o_fzi2.ˏ) * f) + (f2 * o_fzi2.ˊ);
            int i4 = 0;
            float f5 = Float.MAX_VALUE;
            int i5 = 0;
            while (i5 < i3) {
                int i6;
                fzp o_fzp2 = o_fzpArr3[i5];
                f2 = (o_fzp2.ॱ * f4) + (o_fzp2.ˊ * f3);
                if (f2 < f5) {
                    i6 = i5;
                } else {
                    f2 = f5;
                    i6 = i4;
                }
                i5++;
                i4 = i6;
                f5 = f2;
            }
            i2 = i4 + 1 < i3 ? i4 + 1 : 0;
            o_fzp = o_fzpArr2[i4];
            fzp o_fzp3 = aVar.ॱ;
            o_fzp3.ˊ = ((o_fzi2.ˊ * o_fzp.ˊ) - (o_fzi2.ˏ * o_fzp.ॱ)) + o_fzn2.ˊ.ˊ;
            o_fzp3.ॱ = ((o_fzp.ॱ * o_fzi2.ˊ) + (o_fzi2.ˏ * o_fzp.ˊ)) + o_fzn2.ˊ.ॱ;
            aVar.ˎ.ˋ = (byte) i;
            aVar.ˎ.ˊ = (byte) i4;
            aVar.ˎ.ॱ = (byte) o.fyn.b.FACE.ordinal();
            aVar.ˎ.ˎ = (byte) o.fyn.b.VERTEX.ordinal();
            o_fzp = o_fzpArr2[i2];
            o_fzp3 = aVar2.ॱ;
            o_fzp3.ˊ = ((o_fzi2.ˊ * o_fzp.ˊ) - (o_fzi2.ˏ * o_fzp.ॱ)) + o_fzn2.ˊ.ˊ;
            o_fzp3.ॱ = ((o_fzp.ॱ * o_fzi2.ˊ) + (o_fzi2.ˏ * o_fzp.ˊ)) + o_fzn2.ˊ.ॱ;
            aVar2.ˎ.ˋ = (byte) i;
            aVar2.ˎ.ˊ = (byte) i2;
            aVar2.ˎ.ॱ = (byte) o.fyn.b.FACE.ordinal();
            aVar2.ˎ.ˎ = (byte) o.fyn.b.VERTEX.ordinal();
            return;
        }
        throw new AssertionError();
    }

    public final void ॱ(fyl o_fyl, fzf o_fzf, fzn o_fzn, fzf o_fzf2, fzn o_fzn2) {
        o_fyl.ˏ = 0;
        float f = o_fzf.ʼ + o_fzf2.ʼ;
        ˋ(this.ˋॱ, o_fzf, o_fzn, o_fzf2, o_fzn2);
        if (this.ˋॱ.ˏ <= f) {
            ˋ(this.ˏॱ, o_fzf2, o_fzn2, o_fzf, o_fzn);
            if (this.ˏॱ.ˏ <= f) {
                int i;
                Object obj;
                fzn o_fzn3;
                fzn o_fzn4;
                fzf o_fzf3;
                fzf o_fzf4;
                if (this.ˏॱ.ˏ > (BarrierParameters.RESTITUTION * fzo.ॱˊ) + this.ˋॱ.ˏ) {
                    i = this.ˏॱ.ˊ;
                    o_fyl.ॱ = o.fyl.d.FACE_B;
                    obj = 1;
                    o_fzn3 = o_fzn;
                    o_fzn4 = o_fzn2;
                    o_fzf3 = o_fzf;
                    o_fzf4 = o_fzf2;
                } else {
                    i = this.ˋॱ.ˊ;
                    o_fyl.ॱ = o.fyl.d.FACE_A;
                    obj = null;
                    o_fzn3 = o_fzn2;
                    o_fzn4 = o_fzn;
                    o_fzf3 = o_fzf2;
                    o_fzf4 = o_fzf;
                }
                fzi o_fzi = o_fzn4.ˏ;
                ˎ(this.ॱˊ, o_fzf4, o_fzn4, i, o_fzf3, o_fzn3);
                int i2 = o_fzf4.ˎ;
                fzp[] o_fzpArr = o_fzf4.ˏ;
                i2 = i + 1 < i2 ? i + 1 : 0;
                this.ᐝॱ.ॱ(o_fzpArr[i]);
                this.ॱˎ.ॱ(o_fzpArr[i2]);
                this.ˊॱ.ˊ = this.ॱˎ.ˊ - this.ᐝॱ.ˊ;
                this.ˊॱ.ॱ = this.ॱˎ.ॱ - this.ᐝॱ.ॱ;
                this.ˊॱ.ॱ();
                this.ͺ.ˊ = 1.0f * this.ˊॱ.ॱ;
                this.ͺ.ॱ = SizeModifier.STABLE_STATE_SCALE * this.ˊॱ.ˊ;
                this.ॱᐝ.ˊ = (this.ᐝॱ.ˊ + this.ॱˎ.ˊ) * 0.5f;
                this.ॱᐝ.ॱ = (this.ᐝॱ.ॱ + this.ॱˎ.ॱ) * 0.5f;
                this.ʻॱ.ˊ = (o_fzi.ˊ * this.ˊॱ.ˊ) - (o_fzi.ˏ * this.ˊॱ.ॱ);
                this.ʻॱ.ॱ = (o_fzi.ˏ * this.ˊॱ.ˊ) + (o_fzi.ˊ * this.ˊॱ.ॱ);
                float f2 = this.ʻॱ.ॱ * 1.0f;
                float f3 = this.ʻॱ.ˊ * SizeModifier.STABLE_STATE_SCALE;
                fzn.ˊ(o_fzn4, this.ᐝॱ, this.ᐝॱ);
                fzn.ˊ(o_fzn4, this.ॱˎ, this.ॱˎ);
                float f4 = (this.ᐝॱ.ॱ * f3) + (this.ᐝॱ.ˊ * f2);
                float f5 = (-((this.ʻॱ.ˊ * this.ᐝॱ.ˊ) + (this.ʻॱ.ॱ * this.ᐝॱ.ॱ))) + f;
                float f6 = ((this.ʻॱ.ˊ * this.ॱˎ.ˊ) + (this.ʻॱ.ॱ * this.ॱˎ.ॱ)) + f;
                this.ʻॱ.ˎ();
                int ˎ = ˎ(this.ॱˋ, this.ॱˊ, this.ʻॱ, f5, i);
                this.ʻॱ.ˎ();
                if (ˎ >= 2 && ˎ(this.ʾ, this.ॱˋ, this.ʻॱ, f6, i2) >= 2) {
                    o_fyl.ˋ.ॱ(this.ͺ);
                    o_fyl.ˎ.ॱ(this.ॱᐝ);
                    ˎ = 0;
                    for (i2 = 0; i2 < fzo.ʼ; i2++) {
                        if (((this.ʾ[i2].ॱ.ˊ * f2) + (this.ʾ[i2].ॱ.ॱ * f3)) - f4 <= f) {
                            fyo o_fyo = o_fyl.ˊ[ˎ];
                            fzp o_fzp = o_fyo.ˊ;
                            float f7 = this.ʾ[i2].ॱ.ˊ - o_fzn3.ˊ.ˊ;
                            float f8 = this.ʾ[i2].ॱ.ॱ - o_fzn3.ˊ.ॱ;
                            o_fzp.ˊ = (o_fzn3.ˏ.ˊ * f7) + (o_fzn3.ˏ.ˏ * f8);
                            o_fzp.ॱ = (f7 * (-o_fzn3.ˏ.ˏ)) + (f8 * o_fzn3.ˏ.ˊ);
                            o_fyo.ˋ.ॱ(this.ʾ[i2].ˎ);
                            if (obj != null) {
                                o_fyo.ˋ.ˊ();
                            }
                            ˎ++;
                        }
                    }
                    o_fyl.ˏ = ˎ;
                }
            }
        }
    }

    public void ˋ(fyl o_fyl, fyy o_fyy, fzn o_fzn, fyz o_fyz, fzn o_fzn2) {
        o_fyl.ˏ = 0;
        fzn.ˏ(o_fzn2, o_fyz.ˏ, this.ʼ);
        fzn.ˎ(o_fzn, this.ʼ, this.ʿ);
        fzp o_fzp = o_fyy.ˋ;
        fzp o_fzp2 = o_fyy.ˊ;
        this.ˈ.ॱ(o_fzp2).ˎ(o_fzp);
        float ˎ = fzp.ˎ(this.ˈ, this.ʼ.ॱ(o_fzp2).ˎ(this.ʿ));
        float ˎ2 = fzp.ˎ(this.ˈ, this.ʼ.ॱ(this.ʿ).ˎ(o_fzp));
        float f = o_fyy.ʼ + o_fyz.ʼ;
        this.ʽॱ.ˊ = (byte) 0;
        this.ʽॱ.ˎ = (byte) o.fyn.b.VERTEX.ordinal();
        if (ˎ2 <= 0.0f) {
            ᐝ.ॱ(this.ʿ).ˎ(o_fzp);
            if (fzp.ˎ(ᐝ, ᐝ) <= f * f) {
                if (o_fyy.ˎ) {
                    this.ʼॱ.ॱ(o_fzp).ˎ(o_fyy.ॱ);
                    if (fzp.ˎ(this.ʼॱ, this.ʼ.ॱ(o_fzp).ˎ(this.ʿ)) > 0.0f) {
                        return;
                    }
                }
                this.ʽॱ.ˋ = (byte) 0;
                this.ʽॱ.ॱ = (byte) o.fyn.b.VERTEX.ordinal();
                o_fyl.ˏ = 1;
                o_fyl.ॱ = o.fyl.d.CIRCLES;
                o_fyl.ˋ.ˊ();
                o_fyl.ˎ.ॱ(o_fzp);
                o_fyl.ˊ[0].ˋ.ॱ(this.ʽॱ);
                o_fyl.ˊ[0].ˊ.ॱ(o_fyz.ˏ);
            }
        } else if (ˎ <= 0.0f) {
            ᐝ.ॱ(this.ʿ).ˎ(o_fzp2);
            if (fzp.ˎ(ᐝ, ᐝ) <= f * f) {
                if (o_fyy.ॱॱ) {
                    o_fzp = o_fyy.ˏ;
                    fzp o_fzp3 = this.ʼॱ;
                    o_fzp3.ॱ(o_fzp).ˎ(o_fzp2);
                    if (fzp.ˎ(o_fzp3, this.ʼ.ॱ(this.ʿ).ˎ(o_fzp2)) > 0.0f) {
                        return;
                    }
                }
                this.ʽॱ.ˋ = (byte) 1;
                this.ʽॱ.ॱ = (byte) o.fyn.b.VERTEX.ordinal();
                o_fyl.ˏ = 1;
                o_fyl.ॱ = o.fyl.d.CIRCLES;
                o_fyl.ˋ.ˊ();
                o_fyl.ˎ.ॱ(o_fzp2);
                o_fyl.ˊ[0].ˋ.ॱ(this.ʽॱ);
                o_fyl.ˊ[0].ˊ.ॱ(o_fyz.ˏ);
            }
        } else {
            float ˎ3 = fzp.ˎ(this.ˈ, this.ˈ);
            if (ˏ || ˎ3 > 0.0f) {
                this.ˉ.ॱ(o_fzp).ˊ(ˎ).ˏ(this.ʼ.ॱ(o_fzp2).ˊ(ˎ2));
                this.ˉ.ˊ(1.0f / ˎ3);
                ᐝ.ॱ(this.ʿ).ˎ(this.ˉ);
                if (fzp.ˎ(ᐝ, ᐝ) <= f * f) {
                    this.ʽ.ˊ = -this.ˈ.ॱ;
                    this.ʽ.ॱ = this.ˈ.ˊ;
                    if (fzp.ˎ(this.ʽ, this.ʼ.ॱ(this.ʿ).ˎ(o_fzp)) < 0.0f) {
                        this.ʽ.ˎ(-this.ʽ.ˊ, -this.ʽ.ॱ);
                    }
                    this.ʽ.ॱ();
                    this.ʽॱ.ˋ = (byte) 0;
                    this.ʽॱ.ॱ = (byte) o.fyn.b.FACE.ordinal();
                    o_fyl.ˏ = 1;
                    o_fyl.ॱ = o.fyl.d.FACE_A;
                    o_fyl.ˋ.ॱ(this.ʽ);
                    o_fyl.ˎ.ॱ(o_fzp);
                    o_fyl.ˊ[0].ˋ.ॱ(this.ʽॱ);
                    o_fyl.ˊ[0].ˊ.ॱ(o_fyz.ˏ);
                    return;
                }
                return;
            }
            throw new AssertionError();
        }
    }

    public void ॱ(fyl o_fyl, fyy o_fyy, fzn o_fzn, fzf o_fzf, fzn o_fzn2) {
        this.ˋˊ.ˎ(o_fyl, o_fyy, o_fzn, o_fzf, o_fzn2);
    }
}
